#include <sstream>
#include "PowerSystemStabilizerDynamics.hpp"
#include "PssIEEE4B.hpp"

#include "Simple_Float.hpp"
#include "Simple_Float.hpp"
#include "Simple_Float.hpp"
#include "Simple_Float.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "Simple_Float.hpp"
#include "Simple_Float.hpp"
#include "Simple_Float.hpp"
#include "Simple_Float.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"

using namespace CIMPP;

PssIEEE4B::PssIEEE4B() {};

PssIEEE4B::~PssIEEE4B() {};






































































bool assign_PssIEEE4B_bwh1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->bwh1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_bwh2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->bwh2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_bwl1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->bwl1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_bwl2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->bwl2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_kh(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->kh;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_kh1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->kh1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_kh11(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->kh11;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_kh17(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->kh17;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_kh2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->kh2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ki(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ki;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ki1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ki1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ki11(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ki11;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ki17(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ki17;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ki2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ki2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_kl(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->kl;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_kl1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->kl1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_kl11(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->kl11;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_kl17(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->kl17;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_kl2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->kl2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_omeganh1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->omeganh1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_omeganh2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->omeganh2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_omeganl1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->omeganl1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_omeganl2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->omeganl2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_th1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->th1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_th10(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->th10;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_th11(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->th11;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_th12(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->th12;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_th2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->th2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_th3(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->th3;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_th4(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->th4;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_th5(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->th5;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_th6(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->th6;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_th7(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->th7;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_th8(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->th8;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_th9(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->th9;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ti1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ti1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ti10(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ti10;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ti11(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ti11;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ti12(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ti12;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ti2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ti2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ti3(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ti3;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ti4(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ti4;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ti5(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ti5;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ti6(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ti6;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ti7(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ti7;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ti8(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ti8;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_ti9(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->ti9;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_tl1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->tl1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_tl10(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->tl10;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_tl11(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->tl11;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_tl12(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->tl12;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_tl2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->tl2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_tl3(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->tl3;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_tl4(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->tl4;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_tl5(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->tl5;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_tl6(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->tl6;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_tl7(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->tl7;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_tl8(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->tl8;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_tl9(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->tl9;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_vhmax(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->vhmax;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_vhmin(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->vhmin;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_vimax(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->vimax;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_vimin(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->vimin;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_vlmax(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->vlmax;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_vlmin(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->vlmin;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_vstmax(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->vstmax;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_PssIEEE4B_vstmin(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(PssIEEE4B* element = dynamic_cast<PssIEEE4B*>(BaseClass_ptr1)) {
                buffer >> element->vstmin;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

namespace CIMPP {
	BaseClass* PssIEEE4B_factory() {
		return new PssIEEE4B;
	}
}

void PssIEEE4B::addConstructToMap(std::unordered_map<std::string, BaseClass* (*)()>& factory_map) {
	factory_map.insert(std::make_pair(std::string("cim:PssIEEE4B"), &PssIEEE4B_factory));
}

void PssIEEE4B::addPrimitiveAssignFnsToMap(std::unordered_map<std::string, assign_function>& assign_map) {
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.bwh1"), &assign_PssIEEE4B_bwh1));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.bwh2"), &assign_PssIEEE4B_bwh2));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.bwl1"), &assign_PssIEEE4B_bwl1));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.bwl2"), &assign_PssIEEE4B_bwl2));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.kh"), &assign_PssIEEE4B_kh));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.kh1"), &assign_PssIEEE4B_kh1));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.kh11"), &assign_PssIEEE4B_kh11));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.kh17"), &assign_PssIEEE4B_kh17));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.kh2"), &assign_PssIEEE4B_kh2));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ki"), &assign_PssIEEE4B_ki));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ki1"), &assign_PssIEEE4B_ki1));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ki11"), &assign_PssIEEE4B_ki11));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ki17"), &assign_PssIEEE4B_ki17));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ki2"), &assign_PssIEEE4B_ki2));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.kl"), &assign_PssIEEE4B_kl));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.kl1"), &assign_PssIEEE4B_kl1));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.kl11"), &assign_PssIEEE4B_kl11));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.kl17"), &assign_PssIEEE4B_kl17));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.kl2"), &assign_PssIEEE4B_kl2));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.omeganh1"), &assign_PssIEEE4B_omeganh1));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.omeganh2"), &assign_PssIEEE4B_omeganh2));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.omeganl1"), &assign_PssIEEE4B_omeganl1));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.omeganl2"), &assign_PssIEEE4B_omeganl2));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.th1"), &assign_PssIEEE4B_th1));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.th10"), &assign_PssIEEE4B_th10));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.th11"), &assign_PssIEEE4B_th11));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.th12"), &assign_PssIEEE4B_th12));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.th2"), &assign_PssIEEE4B_th2));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.th3"), &assign_PssIEEE4B_th3));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.th4"), &assign_PssIEEE4B_th4));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.th5"), &assign_PssIEEE4B_th5));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.th6"), &assign_PssIEEE4B_th6));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.th7"), &assign_PssIEEE4B_th7));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.th8"), &assign_PssIEEE4B_th8));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.th9"), &assign_PssIEEE4B_th9));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ti1"), &assign_PssIEEE4B_ti1));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ti10"), &assign_PssIEEE4B_ti10));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ti11"), &assign_PssIEEE4B_ti11));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ti12"), &assign_PssIEEE4B_ti12));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ti2"), &assign_PssIEEE4B_ti2));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ti3"), &assign_PssIEEE4B_ti3));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ti4"), &assign_PssIEEE4B_ti4));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ti5"), &assign_PssIEEE4B_ti5));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ti6"), &assign_PssIEEE4B_ti6));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ti7"), &assign_PssIEEE4B_ti7));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ti8"), &assign_PssIEEE4B_ti8));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.ti9"), &assign_PssIEEE4B_ti9));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.tl1"), &assign_PssIEEE4B_tl1));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.tl10"), &assign_PssIEEE4B_tl10));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.tl11"), &assign_PssIEEE4B_tl11));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.tl12"), &assign_PssIEEE4B_tl12));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.tl2"), &assign_PssIEEE4B_tl2));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.tl3"), &assign_PssIEEE4B_tl3));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.tl4"), &assign_PssIEEE4B_tl4));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.tl5"), &assign_PssIEEE4B_tl5));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.tl6"), &assign_PssIEEE4B_tl6));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.tl7"), &assign_PssIEEE4B_tl7));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.tl8"), &assign_PssIEEE4B_tl8));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.tl9"), &assign_PssIEEE4B_tl9));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.vhmax"), &assign_PssIEEE4B_vhmax));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.vhmin"), &assign_PssIEEE4B_vhmin));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.vimax"), &assign_PssIEEE4B_vimax));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.vimin"), &assign_PssIEEE4B_vimin));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.vlmax"), &assign_PssIEEE4B_vlmax));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.vlmin"), &assign_PssIEEE4B_vlmin));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.vstmax"), &assign_PssIEEE4B_vstmax));
	assign_map.insert(std::make_pair(std::string("cim:PssIEEE4B.vstmin"), &assign_PssIEEE4B_vstmin));
}

void PssIEEE4B::addClassAssignFnsToMap(std::unordered_map<std::string, class_assign_function>& assign_map) {
																																																																			}

const char PssIEEE4B::debugName[] = "PssIEEE4B";
const char* PssIEEE4B::debugString()
{
	return PssIEEE4B::debugName;
}

const BaseClassDefiner PssIEEE4B::declare()
{
	return BaseClassDefiner(PssIEEE4B::addConstructToMap, PssIEEE4B::addPrimitiveAssignFnsToMap, PssIEEE4B::addClassAssignFnsToMap, PssIEEE4B::debugName);
}


